home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / sphigs / sph_srgp.lha / srgp / src / srgp_attrib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-09  |  16.4 KB  |  699 lines
  1. #include "HEADERS.h"
  2. #include "srgplocal.h"
  3.  
  4. #define __CURATT(xx)    srgp__curActiveCanvasSpec.attributes.xx
  5.  
  6.  
  7. #ifdef THINK_C
  8. #include "ChooseWhichQuickDraw.h"
  9. #endif
  10.  
  11. #ifdef X11
  12. static XGCValues gcvals;
  13.  
  14. static unsigned char writemode_table[4] = {
  15.    /*REPLACE*/    0x3, /* GXcopy from /usr/include/X11/X.h */
  16.    /*XOR*/     0x6, /* GXxor */
  17.    /*OR*/     0x7, /* GXor */
  18.    /*AND*/     0x1  /* GXand */
  19. };
  20.   
  21. static unsigned char inv_writemode_table[4] = {
  22.    /*REPLACE*/ 0x3, /* GXcopy */
  23.    /*XOR*/     0x9, /* GXequiv */
  24.    /*OR*/      0x1, /* GXand */
  25.    /*AND*/     0x7  /* GXor */
  26. };
  27.  
  28. #endif
  29.  
  30. #ifdef THINK_C
  31. #ifdef COLOR_QUICKDRAW
  32. static unsigned char transfermode_table[4][4] = {
  33.       /*REPLACE,SOLID*/ patCopy,
  34.       /* pixmap pattern entries in this table are unused */ 0,
  35.       /*REPLACE,BITMAP_PATTERN_TRANSPARENT*/ patOr,
  36.       /*REPLACE,BITMAP_PATTERN_OPAQUE*/ patCopy,
  37.       /*XOR,SOLID*/ patXor,
  38.       /* pixmap pattern entries in this table are unused */ 0,
  39.       /*XOR,BITMAP_PATTERN_TRANSPARENT*/ patXor,
  40.       /*XOR,BITMAP_PATTERN_OPAQUE*/ patXor,
  41.       /*OR,SOLID*/ patOr,
  42.       /* pixmap pattern entries in this table are unused */ 0,
  43.       /*OR,BITMAP_PATTERN_TRANSPARENT*/ patOr,
  44.       /*OR,BITMAP_PATTERN_OPAQUE*/ patOr,
  45.       /*AND,SOLID*/ notPatBic,
  46.       /* pixmap pattern entries in this table are unused */ 0,
  47.       /*AND,BITMAP_PATTERN_TRANSPARENT*/ notPatBic,
  48.       /*AND,BITMAP_PATTERN_OPAQUE*/ notPatBic
  49. };
  50.  
  51.  
  52. #define ComputeFrameTransfermode() \
  53.    srgp__curActiveCanvasSpec.transfermode_frame = \
  54.       transfermode_table \
  55.          [srgp__curActiveCanvasSpec.attributes.write_mode] \
  56.          [srgp__curActiveCanvasSpec.attributes.pen_style]
  57.  
  58. #define ComputeFillTransfermode() \
  59.    srgp__curActiveCanvasSpec.transfermode_fill = \
  60.       transfermode_table \
  61.          [srgp__curActiveCanvasSpec.attributes.write_mode] \
  62.          [srgp__curActiveCanvasSpec.attributes.fill_style]
  63.  
  64. #define SetTextTransfermode() \
  65.    TextMode (transfermode_table \
  66.            [srgp__curActiveCanvasSpec.attributes.write_mode] \
  67.            [BITMAP_PATTERN_TRANSPARENT] \
  68.             - 8)
  69.            
  70. #else
  71.  
  72. #define DONT_DRAW   -1
  73.  
  74. static unsigned char transfermode_table[4][2][4] = {
  75.   {
  76.     /*REPLACE,WHITE,...*/ {notPatCopy, 0, patBic, notPatCopy},
  77.     /*REPLACE,BLACK,...*/ {patCopy, 0, patOr, patCopy},
  78.   },
  79.   {
  80.     /*XOR,WHITE,...*/ {notPatXor, 0, DONT_DRAW, notPatXor},
  81.     /*XOR,BLACK,...*/ {patXor, 0, patXor, patXor} 
  82.   },
  83.   {
  84.     /*OR,WHITE,...*/ {notPatOr, 0, DONT_DRAW, notPatOr},
  85.     /*OR,BLACK,...*/ {patOr, 0, patOr, patOr} 
  86.   },
  87.   {
  88.     /*AND,WHITE,...*/ {patBic, 0, DONT_DRAW, patBic},
  89.     /*AND,BLACK,...*/ {notPatBic, 0, notPatBic, notPatBic} 
  90.   }
  91. };
  92.  
  93.  
  94. static void ComputeFrameTransfermode (void)
  95. {
  96.    srgp__curActiveCanvasSpec.transfermode_frame = 
  97.       transfermode_table[srgp__curActiveCanvasSpec.attributes.write_mode]
  98.            [srgp__curActiveCanvasSpec.attributes.color]
  99.            [srgp__curActiveCanvasSpec.attributes.pen_style];
  100. }
  101.  
  102. static void ComputeFillTransfermode (void)
  103. {
  104.    srgp__curActiveCanvasSpec.transfermode_fill = 
  105.       transfermode_table[srgp__curActiveCanvasSpec.attributes.write_mode]
  106.            [srgp__curActiveCanvasSpec.attributes.color]
  107.            [srgp__curActiveCanvasSpec.attributes.pen_style];
  108. }
  109.  
  110. static void SetTextTransfermode (void) {
  111.    TextMode (transfermode_table
  112.            [srgp__curActiveCanvasSpec.attributes.write_mode] 
  113.         [srgp__curActiveCanvasSpec.attributes.color]
  114.            [BITMAP_PATTERN_TRANSPARENT]
  115.             - 8);
  116. }
  117.  
  118. #endif
  119.  
  120. #endif
  121.  
  122.  
  123.  
  124.  
  125. /** WRITE_MODE
  126. X11 implementation:
  127.    Both GC's must be modified.
  128. **/
  129.  
  130. void
  131. SRGP_setWriteMode (writeMode value)
  132. {
  133.    if (value == __CURATT(write_mode)) return;
  134.  
  135.    DEBUG_AIDS{
  136.       SRGP_trace (SRGP_logStream, "SRGP_setWriteMode  %d\n", value);
  137.       srgp_check_system_state();
  138.       srgp_check_write_mode(value);
  139.       LeaveIfNonFatalErr();
  140.    }
  141.  
  142.    srgp__curActiveCanvasSpec.attributes.write_mode = value;
  143.  
  144. #ifdef X11
  145.    if (XWHITE == 0)
  146.        value = writemode_table[value];
  147.    else
  148.        value = inv_writemode_table[value];
  149.    XSetFunction
  150.       (srgpx__display,
  151.        srgp__curActiveCanvasSpec.gc_frame,
  152.        value);
  153.    XSetFunction
  154.       (srgpx__display,
  155.        srgp__curActiveCanvasSpec.gc_fill,
  156.        value);
  157. #endif
  158. #ifdef THINK_C
  159.    ComputeFrameTransfermode();
  160.    ComputeFillTransfermode();
  161.    SetTextTransfermode();
  162. #endif
  163. }
  164.  
  165.  
  166.  
  167. /** CLIP_RECTANGLE
  168. Both GC's must be modified.
  169. **/
  170. void
  171. SRGP_setClipRectangle (rectangle rect)
  172. {
  173. #ifdef X11
  174.    XRectangle xrect;
  175. #endif
  176. #ifdef THINK_C
  177.    Rect r;
  178. #endif
  179.  
  180.    DEBUG_AIDS{
  181.       SRGP_trace (SRGP_logStream, "SRGP_setClipRect  (%d,%d)->(%d,%d)\n", ExplodeRect(rect));
  182.       srgp_check_system_state();
  183.       srgp_check_rectangle
  184.      (rect.bottom_left.x, rect.bottom_left.y,
  185.       rect.top_right.x, rect.top_right.y);
  186.       LeaveIfNonFatalErr();
  187.    }
  188.  
  189.    srgp__curActiveCanvasSpec.attributes.clip_rectangle = rect;
  190.    
  191. #ifdef X11
  192.    xrect.x = rect.bottom_left.x;
  193.    xrect.y = FIXED(rect.top_right.y);
  194.    xrect.width = (rect.top_right.x - rect.bottom_left.x + 1);
  195.    xrect.height = (rect.top_right.y - rect.bottom_left.y + 1);
  196.    XSetClipRectangles
  197.       (srgpx__display,
  198.        srgp__curActiveCanvasSpec.gc_frame,
  199.        0, 0,
  200.        &xrect, 1, YXSorted);
  201.    XSetClipRectangles
  202.       (srgpx__display,
  203.        srgp__curActiveCanvasSpec.gc_fill,
  204.        0, 0,
  205.        &xrect, 1, YXSorted);
  206. #endif
  207.  
  208. #ifdef THINK_C
  209.    r = FIXED_RECT(ExplodeRect(rect));
  210.    ClipRect(&r);
  211. #endif
  212. }
  213.  
  214.  
  215.  
  216.  
  217. /** FILL STYLE
  218. Only the fill GC is to be modified.
  219. The SRGP fill-style maps directly to X's fill-style.
  220. **/
  221. void
  222. SRGP_setFillStyle (drawStyle value)
  223. {
  224.    if (value == __CURATT(fill_style)) return;
  225.  
  226.    DEBUG_AIDS{
  227.       SRGP_trace (SRGP_logStream, "SRGP_setFillStyle  %d\n", value);
  228.       srgp_check_system_state();
  229.       srgp_check_fill_style(value);
  230.       LeaveIfNonFatalErr();
  231.    }
  232.    
  233.    srgp__curActiveCanvasSpec.attributes.fill_style = value;
  234.    
  235. #ifdef X11
  236.    XSetFillStyle (srgpx__display, srgp__curActiveCanvasSpec.gc_fill, value);
  237. #endif
  238.  
  239. #ifdef THINK_C
  240.    ComputeFillTransfermode();
  241.    srgp__curActiveCanvasSpec.pat_fill = (Pattern*)
  242.       ((value == SOLID) ?
  243.           black :  /*Mac's "solid" pattern*/
  244.           srgp__bitmapPatternTable
  245.              [srgp__curActiveCanvasSpec.attributes.fill_bitmap_pattern_id]);
  246. #endif      
  247. }
  248.  
  249. /*!*/
  250. void
  251. SRGP_setFillBitmapPattern (int value)
  252. {
  253.    if (value == __CURATT(fill_bitmap_pattern_id)) return;
  254.  
  255.    DEBUG_AIDS{
  256.       SRGP_trace (SRGP_logStream, "SRGP_setFillBitmapPattern  %d\n", value);
  257.       srgp_check_system_state();
  258.       srgp_check_pattern_index(value);
  259.       srgp_check_pattern_table_entry(srgp__bitmapPatternTable[value]);
  260.       LeaveIfNonFatalErr();
  261.    }
  262.  
  263.    srgp__curActiveCanvasSpec.attributes.fill_bitmap_pattern_id = value;
  264.  
  265. #ifdef X11
  266.    XSetStipple
  267.       (srgpx__display,
  268.        srgp__curActiveCanvasSpec.gc_fill,
  269.        srgp__bitmapPatternTable[value]);
  270. #endif
  271.  
  272. #ifdef THINK_C
  273.    if (srgp__curActiveCanvasSpec.attributes.fill_style != SOLID)
  274.       srgp__curActiveCanvasSpec.pat_fill = (Pattern*)srgp__bitmapPatternTable[value];
  275. #endif
  276. }
  277.  
  278. /*!*/
  279. void
  280. SRGP_setFillPixmapPattern (int value)
  281. {
  282.    if (value == __CURATT(fill_pixmap_pattern_id)) return;
  283.       
  284.    DEBUG_AIDS{
  285.       SRGP_trace (SRGP_logStream, "SRGP_setFillPixmapPattern  %d\n", value);
  286.       srgp_check_system_state();
  287.       srgp_check_pattern_index(value);
  288.       srgp_check_pattern_table_entry(srgp__pixmapPatternTable[value]);
  289.       LeaveIfNonFatalErr();
  290.    }
  291.  
  292.    srgp__curActiveCanvasSpec.attributes.fill_pixmap_pattern_id = value;
  293.  
  294. #ifdef X11
  295.    gcvals.tile = srgp__pixmapPatternTable[value];
  296.    XChangeGC (srgpx__display, srgp__curActiveCanvasSpec.gc_fill,
  297.           GCTile, &gcvals);
  298. #endif
  299. } 
  300.  
  301.  
  302.  
  303.  
  304.  
  305.  
  306.  
  307.  
  308. /** PEN STYLE
  309. X11 implementation:
  310.    Only the frame GC is to be modified.
  311.    The SRGP pen-style maps directly to X's fill-style.
  312. **/
  313.  
  314. void
  315. SRGP_setPenStyle (drawStyle value)
  316. {
  317.    if (value == __CURATT(pen_style)) return;
  318.  
  319.    DEBUG_AIDS{
  320.       SRGP_trace (SRGP_logStream, "SRGP_setPenStyle  %d\n", value);
  321.       srgp_check_system_state();
  322.       srgp_check_fill_style(value);
  323.       LeaveIfNonFatalErr();
  324.    }
  325.  
  326.    srgp__curActiveCanvasSpec.attributes.pen_style = value;
  327.  
  328. #ifdef X11
  329.    XSetFillStyle (srgpx__display, srgp__curActiveCanvasSpec.gc_frame, value);
  330. #endif
  331. #ifdef THINK_C
  332.    ComputeFrameTransfermode();
  333.    srgp__curActiveCanvasSpec.pat_frame = (Pattern*)
  334.       ((value == SOLID) ?
  335.          black :  /*Mac's "solid" pattern*/
  336.          srgp__bitmapPatternTable
  337.             [srgp__curActiveCanvasSpec.attributes.pen_bitmap_pattern_id]);
  338. #endif      
  339. }
  340.  
  341. /*!*/
  342. void
  343. SRGP_setPenBitmapPattern (int value)
  344. {
  345.    if (value == __CURATT(pen_bitmap_pattern_id)) return;
  346.  
  347.    DEBUG_AIDS{
  348.       SRGP_trace (SRGP_logStream, "SRGP_setPenBitmapPattern  %d\n", value);
  349.       srgp_check_system_state();
  350.       srgp_check_pattern_index(value);
  351.       srgp_check_pattern_table_entry(srgp__bitmapPatternTable[value]);
  352.       LeaveIfNonFatalErr();
  353.    }
  354.  
  355.    srgp__curActiveCanvasSpec.attributes.pen_bitmap_pattern_id = value;
  356.  
  357. #ifdef X11
  358.    XSetStipple
  359.       (srgpx__display,
  360.        srgp__curActiveCanvasSpec.gc_frame,
  361.        srgp__bitmapPatternTable[value]);
  362. #endif
  363.  
  364. #ifdef THINK_C
  365.    if (srgp__curActiveCanvasSpec.attributes.pen_style != SOLID)
  366.       srgp__curActiveCanvasSpec.pat_frame = 
  367.          (Pattern*) srgp__bitmapPatternTable[value];
  368. #endif
  369. }
  370.  
  371.  
  372.  
  373. /*!*/
  374. void
  375. SRGP_setPenPixmapPattern (int value)
  376. {
  377.    if (value == __CURATT(pen_pixmap_pattern_id)) return;
  378.  
  379.    DEBUG_AIDS{
  380.       SRGP_trace (SRGP_logStream, "SRGP_setPenPixmapPattern  %d\n", value);
  381.       srgp_check_system_state();
  382.       srgp_check_pattern_index(value);
  383.       srgp_check_pattern_table_entry(srgp__pixmapPatternTable[value]);
  384.       LeaveIfNonFatalErr();
  385.    }
  386.  
  387.    srgp__curActiveCanvasSpec.attributes.pen_pixmap_pattern_id = value;
  388.  
  389. #ifdef X11
  390.    gcvals.tile = srgp__pixmapPatternTable[value];
  391.    XChangeGC (srgpx__display, srgp__curActiveCanvasSpec.gc_frame,
  392.           GCTile, &gcvals);
  393. #endif
  394. }
  395.  
  396.  
  397.  
  398.  
  399.  
  400.  
  401. /** MARKER ATTRIBUTES
  402. **/
  403.  
  404. void 
  405. SRGP_setMarkerSize (int value)
  406. {
  407.    if (value == __CURATT(marker_size)) return;
  408.  
  409.    DEBUG_AIDS{
  410.       SRGP_trace (SRGP_logStream, "SRGP_setMarkerSize  %d\n", value);
  411.       srgp_check_system_state();
  412.       srgp_check_marker_size(value);
  413.       LeaveIfNonFatalErr();
  414.    }
  415.  
  416.    srgp__curActiveCanvasSpec.attributes.marker_size = value;
  417. }
  418.  
  419.  
  420. void 
  421. SRGP_setMarkerStyle (markerStyle value)
  422. {
  423.    if (value == __CURATT(marker_style)) return;
  424.  
  425.    DEBUG_AIDS{
  426.       SRGP_trace (SRGP_logStream, "SRGP_setMarkerStyle  %d\n", value);
  427.       srgp_check_system_state();
  428.       srgp_check_marker_style(value);
  429.       LeaveIfNonFatalErr();
  430.    }
  431.  
  432.    srgp__curActiveCanvasSpec.attributes.marker_style = value;
  433. }
  434.  
  435.  
  436.  
  437. #ifdef X11
  438. /** TRANSLATING SRGP DASHES TO X 
  439. **/
  440. #define LENGTH_OF_DASH_LIST   4
  441. static char dot[] = {4,4,4,4};
  442. static char dash[] = {10,5,10,5};
  443. static char dotdash[] = {12,4,4,4};
  444. static char *(dashmap[NUMBER_OF_LINE_STYLES]) =
  445.    { /*CONTINUOUS: unimportant*/ 0,
  446.      /*DASHED*/ dash,
  447.      /*DOTTED*/ dot,
  448.      /*DOT_DASHED*/ dotdash };
  449.  
  450.  
  451. /** STATIC INTERNAL: SetXLineAttributes()
  452. Notice that when the user desires a line-width of 1, we use 0.
  453. This uses the hardware's fastest line-drawer, according to X.
  454. **/
  455.  
  456. static void SetXLineAttributes()
  457. {
  458.    XSetLineAttributes
  459.       (
  460.        srgpx__display,
  461.        srgp__curActiveCanvasSpec.gc_frame,
  462.        ((srgp__curActiveCanvasSpec.attributes.line_width == 1) ?
  463.     0 : srgp__curActiveCanvasSpec.attributes.line_width),
  464.        ((srgp__curActiveCanvasSpec.attributes.line_style==CONTINUOUS) ?
  465.     LineSolid : LineOnOffDash),
  466.        CapButt,        /* CAPS and JOINS are no-ops when line width = 0 */
  467.        JoinBevel);
  468. }
  469. #endif
  470.  
  471.  
  472.  
  473. /*!*/
  474. void
  475. SRGP_setLineStyle (lineStyle value)
  476. {
  477.    if (value == __CURATT(line_style)) return;
  478.  
  479.    DEBUG_AIDS{
  480.       SRGP_trace (SRGP_logStream, "SRGP_setLineStyle  %d\n", value);
  481.       srgp_check_system_state();
  482.       srgp_check_line_style(value);
  483.       LeaveIfNonFatalErr();
  484.    }
  485.  
  486.    srgp__curActiveCanvasSpec.attributes.line_style = value;
  487.  
  488. #ifdef X11
  489.    if (value != CONTINUOUS)
  490.       XSetDashes (srgpx__display, srgp__curActiveCanvasSpec.gc_frame,
  491.           0, dashmap[value], LENGTH_OF_DASH_LIST);
  492.    SetXLineAttributes();
  493. #endif
  494. }
  495.  
  496.  
  497.  
  498. /*!*/
  499. void
  500. SRGP_setLineWidth (int value)
  501. {
  502.    if (value == __CURATT(line_width)) return;
  503.  
  504.    DEBUG_AIDS{
  505.       SRGP_trace (SRGP_logStream, "SRGP_setLineWidth  %d\n", value);
  506.       srgp_check_system_state();
  507.       srgp_check_line_width(value);
  508.       LeaveIfNonFatalErr();
  509.    }
  510.  
  511.    srgp__curActiveCanvasSpec.attributes.line_width = value;
  512.    
  513. #ifdef X11
  514.    SetXLineAttributes ();
  515. #endif
  516. #ifdef THINK_C
  517.    PenSize (value,value);
  518. #endif
  519. } 
  520.  
  521.  
  522.  
  523.  
  524.  
  525. /** ATTRIBUTES RELATED TO COLOR
  526. **/
  527.  
  528. void
  529. SRGP_setPlaneMask (int value)
  530. {
  531.    if (value == __CURATT(plane_mask)) return;
  532.  
  533.    DEBUG_AIDS{
  534.       SRGP_trace (SRGP_logStream, "SRGP_setPlaneMask  %x\n", value);
  535.       srgp_check_system_state();
  536.       LeaveIfNonFatalErr();
  537.    }
  538.  
  539.    srgp__curActiveCanvasSpec.attributes.plane_mask = value;
  540.  
  541. #ifdef X11
  542.    XSetPlaneMask
  543.       (srgpx__display, 
  544.        srgp__curActiveCanvasSpec.gc_fill, (unsigned long) value);
  545.    XSetPlaneMask
  546.       (srgpx__display, 
  547.        srgp__curActiveCanvasSpec.gc_frame, (unsigned long) value);
  548. #endif
  549. }
  550.  
  551.  
  552. void
  553. SRGP_setColor (int value)
  554. {
  555.    if (value == __CURATT(color)) return;
  556.  
  557.    DEBUG_AIDS{
  558.       SRGP_trace (SRGP_logStream, "SRGP_setColor  %x\n", value);
  559.       srgp_check_system_state();
  560.       SRGP_correct_color(value);
  561.       LeaveIfNonFatalErr();
  562.    }
  563.  
  564.    if (value > srgp__max_pixel_value)
  565.       value = srgp__max_pixel_value;
  566.    srgp__curActiveCanvasSpec.attributes.color = value;
  567.  
  568. #ifdef X11
  569.    XSetForeground(srgpx__display, srgp__curActiveCanvasSpec.gc_fill,
  570.           XCOLOR(COLORINDEX(value)));
  571.    XSetForeground(srgpx__display, srgp__curActiveCanvasSpec.gc_frame,
  572.           XCOLOR(COLORINDEX(value)));
  573. #endif
  574.  
  575. #ifdef THINK_C
  576. #ifdef COLOR_QUICKDRAW
  577.    srgp__curActiveCanvasSpec.drawable.win->fgColor = (COLORINDEX(value));
  578. #else
  579.    ComputeFrameTransfermode();
  580.    ComputeFillTransfermode();
  581.    SetTextTransfermode();
  582. #endif
  583. #endif
  584. }
  585.  
  586.  
  587.  
  588. void
  589. SRGP_setBackgroundColor (int value)
  590. {
  591.    if (value == __CURATT(background_color)) return;
  592.  
  593.    DEBUG_AIDS{
  594.       SRGP_trace (SRGP_logStream, "SRGP_setBackgroundColor  %x\n", value);
  595.       srgp_check_system_state();
  596.       SRGP_correct_color(value);
  597.       LeaveIfNonFatalErr();
  598.    }
  599.  
  600.    if (value > srgp__max_pixel_value)
  601.       value = srgp__max_pixel_value;
  602.    srgp__curActiveCanvasSpec.attributes.background_color = value;
  603.  
  604. #ifdef X11
  605.    XSetBackground(srgpx__display, srgp__curActiveCanvasSpec.gc_fill,
  606.           XCOLOR(COLORINDEX(value)));
  607.    XSetBackground(srgpx__display, srgp__curActiveCanvasSpec.gc_frame,
  608.           XCOLOR(COLORINDEX(value)));
  609. #endif
  610.  
  611. #ifdef THINK_C
  612. #ifdef COLOR_QUICKDRAW
  613.    srgp__curActiveCanvasSpec.drawable.win->bkColor = (COLORINDEX(value));
  614. #endif
  615. #endif
  616. }
  617.  
  618.  
  619.  
  620. /** Load Single Color
  621. A convenience subroutine for setting a single color table entry
  622. **/
  623. void SRGP_loadSingleColor
  624.    (int startentry,
  625.     unsigned short redi, 
  626.     unsigned short greeni,
  627.     unsigned short bluei)
  628. {
  629.    PUSH_TRACE;
  630.    SRGP_loadColorTable (startentry, 1, &redi, &greeni, &bluei);
  631.    POP_TRACE;
  632. }
  633.  
  634.  
  635.  
  636.  
  637. /** FONT
  638. The frame gc is used to draw text.  This is a cheat, and violates SRGP's
  639. spec.  This will be fixed someday.
  640. **/
  641. void
  642. SRGP_setFont (int value)
  643. {
  644.    if (value == __CURATT(font)) return;
  645.  
  646.    DEBUG_AIDS{
  647.       SRGP_trace (SRGP_logStream, "SRGP_setFont  %d\n", value);
  648.       srgp_check_system_state();
  649.       srgp_check_extant_font(value);
  650.       LeaveIfNonFatalErr();
  651.    }
  652.  
  653.    srgp__curActiveCanvasSpec.attributes.font = value;
  654.  
  655. #ifdef X11
  656.    XSetFont
  657.       (srgpx__display,
  658.        srgp__curActiveCanvasSpec.gc_frame,
  659.        srgp__fontTable[value]->fid);
  660. #endif
  661. #ifdef THINK_C
  662.       TextFont(srgp__fontTable[value].txFont);
  663.       TextSize(srgp__fontTable[value].txSize);
  664.       TextFace(srgp__fontTable[value].txFace);
  665. #endif
  666. }
  667.  
  668.    
  669.  
  670. /** BATCH SET ATTRIBUTES
  671. Woefully inefficient, but at least I don't reset attributes whose
  672. value has not changed.
  673. **/
  674.  
  675. void
  676. SRGP_setAttributes (attribute_group *att_group)
  677. {
  678.    SRGP_trace (SRGP_logStream, "SRGP_setAttributes 0x%x\n", att_group);
  679.    PUSH_TRACE;
  680.    SRGP_setWriteMode (att_group->write_mode);
  681.    SRGP_setClipRectangle (att_group->clip_rectangle);
  682.  
  683.    SRGP_setFont (att_group->font);
  684.    SRGP_setLineStyle (att_group->line_style);
  685.    SRGP_setLineWidth (att_group->line_width);
  686.    SRGP_setColor (att_group->color);
  687.    SRGP_setPlaneMask (att_group->plane_mask);
  688.    SRGP_setBackgroundColor (att_group->background_color);
  689.    SRGP_setFillStyle (att_group->fill_style);
  690.    SRGP_setFillPixmapPattern (att_group->fill_pixmap_pattern_id);
  691.    SRGP_setFillBitmapPattern (att_group->fill_bitmap_pattern_id);
  692.    SRGP_setPenStyle (att_group->pen_style);
  693.    SRGP_setPenPixmapPattern (att_group->pen_pixmap_pattern_id);
  694.    SRGP_setPenBitmapPattern (att_group->pen_bitmap_pattern_id);
  695.    SRGP_setMarkerSize (att_group->marker_size);
  696.    SRGP_setMarkerStyle (att_group->marker_style);
  697.    POP_TRACE;
  698. }
  699.